package com.warningrc.util;

/**
 * 
 * 提供操作数组的工具方法 
 * @author <a href="http://weibo.com/weibowarning">王宁</a><br/>
 * email: <a href="mailto:childe.wangning@gmail.com">childe.wangning@gmail.com</a>
 * @date  2012-3-12
 */
public class Arrays {
	private Arrays() {
	}

	/**
	 * 连接两个byte数组，生成新的byte数组
	 * 
	 * @param b1
	 *            要连接的第一个byte数组
	 * @param len1
	 *            第一个byte数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个byte数组
	 * @param len2
	 *            第二个byte数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的byte数组
	 */
	public static byte[] joint(byte[] b1, int len1, byte[] b2, int len2) {
		b1 = b1 == null ? new byte[0] : b1;
		b2 = b2 == null ? new byte[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		byte[] buffer = new byte[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个int数组，生成新的int数组
	 * 
	 * @param b1
	 *            要连接的第一个int数组
	 * @param len1
	 *            第一个int数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个int数组
	 * @param len2
	 *            第二个int数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的int数组
	 */
	public static int[] joint(int[] b1, int len1, int[] b2, int len2) {
		b1 = b1 == null ? new int[0] : b1;
		b2 = b2 == null ? new int[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		int[] buffer = new int[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个Object数组，生成新的Object数组
	 * 
	 * @param b1
	 *            要连接的第一个Object数组
	 * @param len1
	 *            第一个Object数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个Object数组
	 * @param len2
	 *            第二个Object数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的Object数组
	 */
	public static char[] joint(char[] b1, int len1, char[] b2, int len2) {
		b1 = b1 == null ? new char[0] : b1;
		b2 = b2 == null ? new char[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		char[] buffer = new char[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个Object数组，生成新的Object数组
	 * 
	 * @param b1
	 *            要连接的第一个Object数组
	 * @param len1
	 *            第一个Object数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个Object数组
	 * @param len2
	 *            第二个Object数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的Object数组
	 */
	public static double[] joint(double[] b1, int len1, double[] b2, int len2) {
		b1 = b1 == null ? new double[0] : b1;
		b2 = b2 == null ? new double[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		double[] buffer = new double[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个float数组，生成新的float数组
	 * 
	 * @param b1
	 *            要连接的第一个float数组
	 * @param len1
	 *            第一个float数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个float数组
	 * @param len2
	 *            第二个float数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的float数组
	 */
	public static float[] joint(float[] b1, int len1, float[] b2, int len2) {
		b1 = b1 == null ? new float[0] : b1;
		b2 = b2 == null ? new float[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		float[] buffer = new float[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个boolean数组，生成新的boolean数组
	 * 
	 * @param b1
	 *            要连接的第一个boolean数组
	 * @param len1
	 *            第一个boolean数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个boolean数组
	 * @param len2
	 *            第二个boolean数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的boolean数组
	 */
	public static boolean[] joint(boolean[] b1, int len1, boolean[] b2, int len2) {
		b1 = b1 == null ? new boolean[0] : b1;
		b2 = b2 == null ? new boolean[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		boolean[] buffer = new boolean[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个short数组，生成新的short数组
	 * 
	 * @param b1
	 *            要连接的第一个short数组
	 * @param len1
	 *            第一个short数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个short数组
	 * @param len2
	 *            第二个short数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的short数组
	 */
	public static short[] joint(short[] b1, int len1, short[] b2, int len2) {
		b1 = b1 == null ? new short[0] : b1;
		b2 = b2 == null ? new short[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		short[] buffer = new short[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个long数组，生成新的long数组
	 * 
	 * @param b1
	 *            要连接的第一个long数组
	 * @param len1
	 *            第一个long数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个long数组
	 * @param len2
	 *            第二个long数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的long数组
	 */
	public static long[] joint(long[] b1, int len1, long[] b2, int len2) {
		b1 = b1 == null ? new long[0] : b1;
		b2 = b2 == null ? new long[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		long[] buffer = new long[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个String数组，生成新的String数组
	 * 
	 * @param b1
	 *            要连接的第一个String数组
	 * @param len1
	 *            第一个String数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个String数组
	 * @param len2
	 *            第二个String数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的String数组
	 */
	public static String[] joint(String[] b1, int len1, String[] b2, int len2) {
		b1 = b1 == null ? new String[0] : b1;
		b2 = b2 == null ? new String[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		String[] buffer = new String[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

	/**
	 * 连接两个Object数组，生成新的Object数组
	 * 
	 * @param b1
	 *            要连接的第一个Object数组
	 * @param len1
	 *            第一个Object数组要连接的元素个数
	 * @param b2
	 *            要连接的第二个Object数组
	 * @param len2
	 *            第二个Object数组要连接的元素个数
	 * @return 返回连接后的长度为len1+len2的新的Object数组
	 */
	public static Object[] joint(Object[] b1, int len1, Object[] b2, int len2) {
		b1 = b1 == null ? new Object[0] : b1;
		b2 = b2 == null ? new Object[0] : b2;
		len1 = b1.length > len1 ? len1 < 0 ? 0 : len1 : b1.length;
		len2 = b2.length > len2 ? len2 < 0 ? 0 : len2 : b2.length;
		Object[] buffer = new Object[len1 + len2];
		System.arraycopy(b1, 0, buffer, 0, len1);
		System.arraycopy(b2, 0, buffer, len1, len2);
		return buffer;
	}

}